home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / kimproxy.h < prev    next >
Encoding:
C/C++ Source or Header  |  2005-10-10  |  21.8 KB  |  655 lines
  1. /*
  2.     kimproxy.h
  3.  
  4.     IM service library for KDE
  5.  
  6.     Copyright (c) 2004 Will Stephenson   <lists@stevello.free-online.co.uk>
  7.  
  8.     This library is free software; you can redistribute it and/or
  9.     modify it under the terms of the GNU Library General Public
  10.     License as published by the Free Software Foundation; either
  11.     version 2 of the License, or (at your option) any later version.
  12.  
  13.     This library is distributed in the hope that it will be useful,
  14.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.     Library General Public License for more details.
  17.  
  18.     You should have received a copy of the GNU Library General Public License
  19.     along with this library; see the file COPYING.LIB.  If not, write to
  20.     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21.     Boston, MA 02110-1301, USA.
  22. */
  23.  
  24. #ifndef KIMPROXY_H
  25. #define KIMPROXY_H
  26.  
  27. #include <qdict.h>
  28. #include <qmap.h>
  29. #include <qptrdict.h>
  30. #include <qstringlist.h>
  31.  
  32.  
  33. #define IM_SERVICE_TYPE "DCOP/InstantMessenger"
  34. #define IM_CLIENT_PREFERENCES_FILE "default_components"
  35. #define IM_CLIENT_PREFERENCES_SECTION "InstantMessenger"
  36. #define IM_CLIENT_PREFERENCES_ENTRY "imClient"
  37.  
  38. #include "kimproxyiface.h"
  39.  
  40. class DCOPClient;
  41. class KIMIface_stub;
  42. class KURL;
  43. class ContactPresenceListCurrent;
  44.  
  45. /** FIXME: remove for KDE4, binary compability again. */
  46. typedef QMap<QCString, int> AppPresence;         // appId->presence; contains all applications' ideas of a user's presence
  47. typedef QDict<AppPresence> PresenceMap;            // uid->AppPresence; contains a AppPresences for all users
  48. /** FIXME: remove presenceMap and call this presenceMap in KDE4.  This hack is for binary compatibility */
  49. typedef QMap<QString, ContactPresenceListCurrent> PresenceStringMap;
  50.  
  51. /**
  52.  * @brief Provides access to instant messenger programs which implement KDE's
  53.  *        instant messanger interface KIMIface
  54.  *
  55.  * This class provides an easy-to-use interface to all running instant
  56.  * messengers or chat programs that implement KIMIface.
  57.  *
  58.  * It works simultaneously with any running programs that implement the
  59.  * ServiceType @c DCOP/InstantMessenger.
  60.  *
  61.  * IM-contacts are identified using unique identifier strings (UID) used by
  62.  * KDE's address book framework KABC.
  63.  * However the use of the address book API is optional, KIMProxy provides
  64.  * methods to fetch lists of available contact UIDs from the applications.
  65.  * If a UID is reachable with more than one program, KIMProxy aggregates the
  66.  * available information and presents the 'best' presence.  For example, for a
  67.  * contact who can be seen to be @c Away in @c IRC on program A but @c Online
  68.  * using @c ICQ on program B, the information from program B will be used.
  69.  *
  70.  * KIMProxy is designed for simple information in a wide number of cases, not
  71.  * for detailed messaging.
  72.  *
  73.  * The class is implemented as a singleton, so whenever you need access to
  74.  * one of its methods, just retrieve the single instance using instance().
  75.  * The following code snippet demonstrated how to send a message to all
  76.  * reachable IM-contacts:
  77.  * @code
  78.  * // get proxy instance
  79.  * KIMProxy* proxy = KIMProxy::instance();
  80.  *
  81.  * // check if there are suitable applications reachable
  82.  * if (!proxy->initialize()) return;
  83.  *
  84.  * QString message = "Hi!\nHow are you on this wonderful day?";
  85.  *
  86.  * // iterate over the list of reachable contacts
  87.  * QStringList reachableContacts = proxy->reachableContacts();
  88.  * for (QStringList::const_iterator it = reachableContacts.begin();
  89.  *      it != reachableContacts.end(); ++it)
  90.  * {
  91.        proxy->messageContact(*it, message);
  92.  * }
  93.  * @endcode
  94.  *
  95.  * @note While it is possible to communicate with each of those application's
  96.  * by DCOP using KIMProxy has the advantage of communicating with all
  97.  * applications simultaneously and thus getting an augmented view of
  98.  * availability, capability and presence (online status) of IM-contacts.
  99.  *
  100.  * @see KIMIface
  101.  * @see KABC::AddressBook
  102.  * @see KABC::Addressee
  103.  *
  104.  * @since 3.3
  105.  * @author Will Stephenson <lists@stevello.free-online.co.uk>
  106.  */
  107. class KIMPROXY_EXPORT KIMProxy : public QObject, virtual public KIMProxyIface
  108. {
  109.     Q_OBJECT
  110.     struct Private;
  111.  
  112.     template<class> friend class KStaticDeleter;
  113.     ~KIMProxy();
  114.  
  115.     public:
  116.         /**
  117.          * @brief Obtain an instance of KIMProxy
  118.          *
  119.          * Creates a new instance if it is called for the first time.
  120.          * Call initialize() to check if there are applications available for
  121.          * communication.
  122.          *
  123.          * @note KIMProxy uses DCOPClient::setNotifications() to make sure
  124.          * it updates its information about IM applications it interacts with,
  125.          * e.g. that it gets notified about newly available applications or
  126.          * about applications exiting
  127.          *
  128.          * @param client your application's DCOP client
  129.          * @return the singleton instance of this class
  130.          */
  131.         static KIMProxy * instance( DCOPClient * client );
  132.  
  133.         /**
  134.          * @brief Get the proxy ready to connect
  135.          *
  136.          * Discover any running IM clients and setup communication handlers for
  137.          * them. The list of available clients is updated automatically
  138.          * through notification about added or removed DCOP applications as
  139.          * provided by DCOPClient.
  140.          *
  141.          * It is safe to call this method more than once, initialization only
  142.          * occurs at the first time.
  143.          *
  144.          * @return whether the proxy is ready to use.
  145.          *         @c false if there are no suitable apps running
  146.          */
  147.         bool initialize();
  148.  
  149.         /**
  150.          * @brief Obtain a list of IM-contacts known to IM-applications
  151.          *
  152.          * Returns a list of KABC UIDs gathered by merging the lists of
  153.          * each application the proxy can communicate with.
  154.          * The method uses cached information to make it fast and not
  155.          * require actually communicating with the applications every time
  156.          * it is called.
  157.          *
  158.          * @return a list of KABC UIDs known to any IM-application
  159.          *
  160.          * @see reachableContacts()
  161.          * @see onlineContacts()
  162.          * @see fileTransferContacts()
  163.          * @see isPresent()
  164.          * @see KABC::Addressee::uid()
  165.          */
  166.         QStringList allContacts();
  167.  
  168.         /**
  169.          * @brief Obtain a list of IM-contacts that are currently reachable
  170.          *
  171.          * Returns a list of KABC UIDs gathered by merging the lists of
  172.          * each application the proxy can communicate with.
  173.          *
  174.          * @return a list of KABC UIDs who can receive a message, even if offline
  175.          *
  176.          * @see allContacts()
  177.          * @see onlineContacts()
  178.          * @see fileTransferContacts()
  179.          * @see messageContact()
  180.          * @see KABC::Addressee::uid()
  181.          */
  182.         QStringList reachableContacts();
  183.  
  184.         /**
  185.          * @brief Obtain a list of IM-contacts that are currently online
  186.          *
  187.          * Returns a list of KABC UIDs gathered by merging the lists of
  188.          * each application the proxy can communicate with.
  189.          * The method uses cached information to make it fast and not
  190.          * require actually communicating with the applications every time
  191.          * it is called.
  192.          *
  193.          * @return a list of KABC UIDs who are online with unspecified presence
  194.          *
  195.          * @see allContacts()
  196.          * @see reachableContacts()
  197.          * @see fileTransferContacts()
  198.          * @see messageContact()
  199.          * @see chatWithContact()
  200.          * @see KABC::Addressee::uid()
  201.          */
  202.         QStringList onlineContacts();
  203.  
  204.         /**
  205.          * @brief Obtain a list of IM-contacts who may receive file transfers
  206.          *
  207.          * Returned IM-contacts might not be capable of receiving file
  208.          * tranfers due to limitations of their clients or because they are
  209.          * behind a firewall.
  210.          * KIMProxy doesn't have the possibilities to discover this and will
  211.          * list them as well.
  212.          *
  213.          * Returns a list of KABC UIDs gathered by merging the lists of
  214.          * each application the proxy can communicate with.
  215.          *
  216.          * @return a list of KABC UIDs capable of file transfer
  217.          *
  218.          * @see allContacts()
  219.          * @see reachableContacts()
  220.          * @see onlineContacts()
  221.          * @see canReceiveFiles()
  222.          * @see KABC::Addressee::uid()
  223.          */
  224.         QStringList fileTransferContacts();
  225.  
  226.         /**
  227.          * @brief Confirm if a given contact is known to the proxy
  228.          *
  229.          * A contact is known to the proxy if it is know to at least one
  230.          * IM-application the proxy is communicating with.
  231.          *
  232.          * The method uses cached information to make it fast and not
  233.          * require actually communicating with the applications every time
  234.          * it is called.
  235.          *
  236.          * @param uid the KABC UID you are interested in
  237.          * @return whether any IM-program knows of this KABC UID
  238.          *
  239.          * @see allContacts()
  240.          * @see presenceString()
  241.          * @see presenceNumeric()
  242.          * @see KABC::Addressee::uid()
  243.          */
  244.         bool isPresent( const QString& uid );
  245.  
  246.         /**
  247.          * @brief Obtain the proxy's idea of the contact's display name
  248.          *
  249.          * If the given KABC UID is known to more than one IM-application
  250.          * the result of the application which has the best presence for the
  251.          * contact is taken.
  252.          * For example if a contact is @c Online on ICQ and @c Away on AIM, the
  253.          * value returned by the application providing ICQ is taken.
  254.          *
  255.          * Useful if KABC lookups may be too slow.
  256.          *
  257.          * @param uid the KABC UID you are interested in
  258.          * @return the corresponding display name or QString:null if the
  259.          *         UID is unknown
  260.          *
  261.          * @see isPresent()
  262.          * @see presenceString()
  263.          * @see presenceNumeric()
  264.          * @see KABC::Addressee::uid()
  265.          */
  266.         QString displayName( const QString& uid );
  267.  
  268.         /**
  269.          * @brief Obtain the IM presence as a number for the specified contact
  270.          *
  271.          * Returns one of the following values depending on the given contact's
  272.          * presence:
  273.          * - 0 - @c Unknown: for contacts where you can not use any of the
  274.          *   other values
  275.          *
  276.          * - 1 - @c Offline: for contacts that are offline, i.e. not connected
  277.          *   to their IM-service.
  278.          *
  279.          * - 2 - @c Connecting
  280.          *
  281.          * - 3 - @c Away: for contacts that are connected to their IM-service
  282.          *   but not @c Online
  283.          *
  284.          * - 4 - @c Online
  285.          *
  286.          * If the given KABC UID is known to more than one IM-application
  287.          * the result of the application which has the best presence for the
  288.          * contact is taken.
  289.          * For example if a contact is @c Online on ICQ and Away on AIM, the
  290.          * value returned by the application providing ICQ is taken.
  291.          *
  292.          * The method uses cached information to make it fast and not
  293.          * require actually communicating with the applications every time
  294.          * it is called.
  295.          *
  296.          * @param uid the KABC UID you want the presence for
  297.          * @return a numeric representation of presence - currently one of
  298.          *         0 (Unknown), 1 (Offline), 2 (Connecting), 3 (Away),
  299.          *         4 (Online). Returns 0 if the given UID is unknown
  300.          *
  301.          * @see isPresent()
  302.          * @see presenceString()
  303.          * @see presenceIcon()
  304.          * @see KIMIface::presenceStatus()
  305.          * @see KABC::Addressee::uid()
  306.          */
  307.         int presenceNumeric( const QString& uid );
  308.  
  309.         /**
  310.          * @brief Obtain the IM presence as a i18ned string for the specified
  311.          *        contact
  312.          *
  313.          * The presence string is one of the following:
  314.          * - i18n("Unknown")
  315.          * - i18n("Offline")
  316.          * - i18n("Connecting")
  317.          * - i18n("Away")
  318.          * - i18n("Online")
  319.          *
  320.          * If the given KABC UID is known to more than one IM-application
  321.          * the result of the application which has the best presence for the
  322.          * contact is taken.
  323.          * For example if a contact is @c Online on ICQ and Away on AIM, the
  324.          * value returned by the application providing ICQ is taken.
  325.          *
  326.          * @note The presence string is created based on the numerical
  327.          *       presence value returned by the applications. It currently
  328.          *       does not return the presence strings used by the applications.
  329.          *
  330.          * The method uses cached information to make it fast and not
  331.          * require actually communicating with the applications every time
  332.          * it is called.
  333.          *
  334.          * @param uid the KABC UID you want the presence for
  335.          * @return the i18ned string describing the contact's presence or
  336.          *         QString::null if the UID is unknown
  337.          *
  338.          * @see isPresent()
  339.          * @see presenceNumeric()
  340.          * @see presenceIcon()
  341.          * @see KABC::Addressee::uid()
  342.          */
  343.         QString presenceString( const QString& uid );
  344.  
  345.         /**
  346.          * @brief Obtain the icon representing the IM presence for the
  347.          *        specified contact
  348.          *
  349.          * If the given KABC UID is known to more than one IM-application
  350.          * the result of the application which has the best presence for the
  351.          * contact is taken.
  352.          * For example if a contact is @c Online on ICQ and Away on AIM, the
  353.          * value returned by the application providing ICQ is taken.
  354.          *
  355.          * @note The presence icon is chosen based on the numerical
  356.          *       presence value returned by the applications. It currently
  357.          *       does not return the presence icon used by the applications.
  358.          *
  359.          * The method uses cached information to make it fast and not
  360.          * require actually communicating with the applications every time
  361.          * it is called.
  362.          *
  363.          * @param uid the KABC UID you want the presence icon for
  364.          * @return a pixmap representing the contact's presence or a null
  365.          *         pixmap if the contact is unknown. See QPixmap::isNull()
  366.          *
  367.          * @see isPresent()
  368.          * @see presenceString()
  369.          * @see presenceNumeric()
  370.          * @see KABC::Addressee::uid()
  371.          */
  372.         QPixmap presenceIcon( const QString& uid );
  373.  
  374.         /**
  375.          * @brief Indicate if a given contact can receive files
  376.          *
  377.          * If the given KABC UID is known to more than one IM-application
  378.          * the result of the application which has the best presence for the
  379.          * contact is taken.
  380.          * For example if a contact is @c Online on ICQ and Away on AIM, the
  381.          * value returned by the application providing ICQ is taken.
  382.          *
  383.          * @param uid the KABC UID you want to the file transfer capability for
  384.          * @return whether the specified contact can receive files
  385.          *
  386.          * @see fileTransferContacts()
  387.          * @see KABC::Addressee::uid()
  388.          */
  389.         bool canReceiveFiles( const QString & uid );
  390.  
  391.         /**
  392.          * @brief Indicate if a given contact will be able to respond
  393.          *
  394.          * Some media are unidirectional (e.g., sending SMS via a web
  395.          * interface).
  396.          * This refers to the contact's ability to respond as defined by the
  397.          * medium, not by their presence.
  398.          *
  399.          * Someone may appear offline (SMS has no presence) to you but in fact
  400.          * be able to respond.
  401.          *
  402.          * If the given KABC UID is known to more than one IM-application
  403.          * the result of the application which has the best presence for the
  404.          * contact is taken.
  405.          * For example if a contact is @c Online on ICQ and Away on AIM, the
  406.          * value returned by the application providing ICQ is taken.
  407.          *
  408.          * @param uid the KABC UID you are interested in
  409.          * @return whether the specified contact can respond
  410.          *
  411.          * @see isPresent()
  412.          * @see KABC::Addressee::uid()
  413.          */
  414.         bool canRespond( const QString & uid );
  415.  
  416.         /**
  417.          * @brief Obtain the KABC UID corresponding to the given IM address
  418.          *
  419.          * @param contactId the protocol specific identifier for the contact,
  420.          *        e.g. UIN for ICQ, screenname for AIM, nick for IRC
  421.          * @param protocol the IM protocol/service to check.
  422.          *        See KIMIface::protocols()
  423.          * @return the KABC UID for the given contact or @c QString::null if
  424.          *         not found or either input stream was empty or the protocol
  425.          *         is not supported
  426.          *
  427.          * @see KIMIface::protocols()
  428.          * @see addContact()
  429.          * @see isPresent()
  430.          * @see KABC::Addressee::uid()
  431.          */
  432.         QString locate( const QString & contactId, const QString & protocol );
  433.  
  434.         /**
  435.          * @brief Obtain the given contact's current context (home, work, or
  436.          *        any)
  437.          *
  438.          * Not all IM services/protocols support the concept of contexts. If the
  439.          * given UID maps to such a service, @c QString::null will be returned
  440.          *
  441.          * If the given KABC UID is known to more than one IM-application
  442.          * the result of the application which has the best presence for the
  443.          * contact is taken.
  444.          * For example if a contact is @c Online on ICQ and Away on AIM, the
  445.          * value returned by the application providing ICQ is taken.
  446.          *
  447.          * @param uid the KABC UID you want the context for
  448.          * @return a string describing the context, or @c QString::null if not
  449.          *         supported or if the contact is unknown
  450.          *
  451.          * @see isPresent()
  452.          * @see KABC::Addressee::uid()
  453.          */
  454.         QString context( const QString & uid );
  455.  
  456.         /**
  457.          * @brief Start a chat session with the specified contact
  458.          *
  459.          * @param uid the KABC UID you want to chat with
  460.          *
  461.          * @see messageContact()
  462.          * @see sendFile()
  463.          * @see isPresent()
  464.          * @see reachableContacts()
  465.          * @see KABC::Addressee::uid()
  466.          */
  467.         void chatWithContact( const QString& uid );
  468.  
  469.         /**
  470.          * @brief Send a single message to the specified contact
  471.          *
  472.          * Any response will be handled by the IM client as a normal
  473.          * conversation.
  474.          *
  475.          * @param uid the KABC UID you want to send the message to
  476.          * @param message the message text to send to the contact
  477.          *
  478.          * @see chatWithContact()
  479.          * @see sendFile()
  480.          * @see isPresent()
  481.          * @see reachableContacts()
  482.          * @see KABC::Addressee::uid()
  483.          */
  484.         void messageContact( const QString& uid, const QString& message );
  485.  
  486.         /**
  487.          * @brief Send a file to the contact
  488.          *
  489.          * Initiates a file transfer with the given contact if possible.
  490.          *
  491.          * @param uid the KABC UID you want to send to
  492.          * @param sourceURL a KURL pointing to the file to send
  493.          * @param altFileName an alternate filename describing the file or a
  494.          *        description or title
  495.          * @param fileSize file size in bytes
  496.          *
  497.          * @see messageContact()
  498.          * @see chatWithContact()
  499.          * @see isPresent()
  500.          * @see fileTransferContacts()
  501.          * @see KABC::Addressee::uid()
  502.          */
  503.         void sendFile(const QString &uid, const KURL &sourceURL,
  504.              const QString &altFileName = QString::null, uint fileSize = 0);
  505.  
  506.         /**
  507.          * @brief Add a new contact given its protocol specific identifier
  508.          *
  509.          * @param contactId the protocol specific identifier for the contact
  510.          *        e.g. UIN for ICQ, screenname for AIM, nick for IRC
  511.          * @param protocol the IM protocol/service to use.
  512.          *        See KIMIface:::protocols()
  513.          * @return whether the add succeeded. @c false may signal already present,
  514.          *         protocol not supported, or add operation not supported.
  515.          *
  516.          * @see locate()
  517.          * @see KIMIface::protocols()
  518.          */
  519.         bool addContact( const QString &contactId, const QString &protocol );
  520.  
  521.         /**
  522.          * @brief Checks if there are any compatible instant messaging
  523.          *        applications available
  524.          *
  525.          * Available means that they are started and registered with DCOP
  526.          * and implementing the correct DCOP service.
  527.          * This information will be updated on the first call to initialize()
  528.          * and whenever an application registers or unregisters with DCOP,
  529.          * i.e. the information will be kept up to date.
  530.          *
  531.          * @return @c true if there are any apps available
  532.          */
  533.         bool imAppsAvailable();
  534.  
  535.         /**
  536.          * @brief Start the user's preferred IM application
  537.          * @return whether a preferred app was found. No guarantee that it
  538.          *         started correctly
  539.          */
  540.         bool startPreferredApp();
  541.  
  542.         /**
  543.          * Just exists to let the IDL compiler make the DCOP signal for this
  544.          */
  545.         void contactPresenceChanged( QString uid, QCString appId, int presence );
  546.  
  547.     public slots:
  548.         /**
  549.          * @brief Updates the proxy's data after a new application registered
  550.          *        with DCOP
  551.          *
  552.          * Checks if the application specified by the given DCOP application
  553.          * identifier implements the instant messenger service.
  554.          *
  555.          * @param appId the DCOP application ID of the newly registered
  556.          *        application
  557.          *
  558.          * @see DCOPClient::applicationRegistered()
  559.          */
  560.         void registeredToDCOP( const QCString& appId );
  561.  
  562.         /**
  563.          * @brief Updates the proxy's data after an application unregistered
  564.          *        with DCOP
  565.          *
  566.          * If the application specified by the given DCOP application
  567.          * identifier is one of the instant messenger applications of the
  568.          * proxy, it will remove the presence information it gathered from it
  569.          * earlier on.
  570.          *
  571.          * Emits sigPresenceInfoExpired() to let the using applcation know
  572.          * its presence related information might need updating.
  573.          *
  574.          * @param appId the DCOP application ID of the now unregistered
  575.          *        application
  576.          *
  577.          * @see DCOPClient::applicationRemoved()
  578.          */
  579.         void unregisteredFromDCOP( const QCString& appId );
  580.     signals:
  581.         /**
  582.          * @brief Indicates that the specified IM-contact's presence changed
  583.          *
  584.          * @param uid the KABC UID whose presence changed
  585.          *
  586.          * @see isPresent()
  587.          * @see presenceNumeric()
  588.          * @see presenceIcon()
  589.          * @see KABC::Addressee::uid()
  590.          */
  591.         void sigContactPresenceChanged( const QString &uid );
  592.  
  593.         /**
  594.          * @brief Indicates that presence information obtained earlier on might
  595.          *        not be valid any longer
  596.          *
  597.          * After the sources of presence information have changed so any
  598.          * previously supplied presence info is invalid.
  599.          */
  600.         void sigPresenceInfoExpired();
  601.     protected:
  602.         /**
  603.          * Bootstrap our presence data for a newly registered app
  604.          */
  605.         void pollApp( const QCString & appId );
  606.         /**
  607.          * Bootstrap our presence data by polling all known apps
  608.          */
  609.         void pollAll( const QString &uid );
  610.  
  611.         /**
  612.          * Update our records with the given data
  613.          */
  614.         bool updatePresence( const QString &uid, const QCString &appId, int presence );
  615.  
  616.         /**
  617.          * Get the name of the user's IM application of choice
  618.          */
  619.         QString preferredApp();
  620.  
  621.         /**
  622.          * Get the app stub best able to reach this uid
  623.          */
  624.         KIMIface_stub * stubForUid( const QString &uid );
  625.  
  626.         /**
  627.          * Get the app stub for this protocol.
  628.          * Take the preferred app first, then any other.
  629.          */
  630.         KIMIface_stub * stubForProtocol( const QString &protocol );
  631.  
  632.     private:
  633.         // client stubs used to get presence
  634.         // appId (from DCOP) -> KIMIface_stub
  635.         QDict<KIMIface_stub> m_im_client_stubs;
  636.         // map containing numeric presence and the originating application ID for each KABC uid we know of
  637.         // KABC Uid -> (appId, numeric presence )(AppPresence)
  638.         PresenceMap m_presence_map;
  639.         // cache of the client strings in use by each application
  640.         // dictionary of KIMIface_stub -> map of numeric presence -> string presence
  641.         // FIXME: remove for KDE4 - UNUSED but maintained for binary compatibility in KDE 3.4
  642.         QPtrDict<int> m_client_presence_strings;
  643.         Private * d;
  644.         bool m_apps_available;
  645.         bool m_initialized;
  646.         /**
  647.          * Construct an instance of the proxy library.
  648.          */
  649.         KIMProxy( DCOPClient * client);
  650.         static KIMProxy * s_instance;
  651. };
  652.  
  653. #endif
  654.  
  655.